home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Celestin Apprentice 5
/
Apprentice-Release5.iso
/
Demos
/
A.D. Software
/
OOFILE
/
Buildable, limited OOFILE
/
source
/
GUI
/
zApp-old
/
oofzapp.cpp
next >
Wrap
Text File
|
1995-06-04
|
30KB
|
1,263 lines
// COPYRIGHT 1994 A.D. Software, All rights reserved
// zApp Integration layer of OOFILE database
#include "zapp.hpp"
#include "OOFzApp.hpp"
#include "stdlib.h"
#ifdef _Windows
#include <strstrea.h>
#else
#include <strstream.h>
#endif
#include "fstream.h"
// static variables
dbEditMgr* dbEditMgr::sFrontmost;
zFont* dbEditMgr::sDefEditFont;
// utility function
char* newFileNameFromPath(const char*path) {
#ifdef __BORLANDC__
char name[_MAX_FNAME];
char ext[_MAX_EXT];
char* ret;
int nameLen = _MAX_FNAME + _MAX_EXT;
_splitpath(path, 0, 0, name, ext);
ret = new char[nameLen];
assert(ret);
strcpy(ret, name);
strcat(ret, ext);
return ret; // WARNING receiver must delete!
#else
assert(0); // force an error if function not avail
#endif
}
// -------------------------------------------------------
// d b E d i t M g r
// -------------------------------------------------------
dbEditMgr::dbEditMgr() :
mEditing(false),
mNew(false),
mChangingPages(false),
mCurrPageCommandNum(0),
mMenu(0),
mCurrDialog(0),
mPages(0),
mDefEditFontSpec("MS Sans Serif", zDimension(0, -11),
FW_NORMAL, ffSwiss, VariablePitch,
0, 0, 0, AnsiCharSet, StringOutPrec, StrokeClipPrec, DraftQual)
{
sFrontmost=this;
};
zFont* dbEditMgr::enableDefEditFont()
{
#ifdef OOF_Debug
if (sDefEditFont)
dbConnect::raise("dbEditMgr::enableDefEditFont called with non-zero font left in place");
#endif
sDefEditFont = new zFont(mDefEditFontSpec);
return sDefEditFont;
}
void dbEditMgr::setDefEditFont(zFont* theFont)
{
#ifdef OOF_Debug
if (sDefEditFont)
dbConnect::raise("dbEditMgr::setDefEditFont called with non-zero font left in place");
#endif
sDefEditFont = theFont;
}
void dbEditMgr::leavingPage(zVBXFormDialog* leavingFrom)
{
// NOT IF RETAIN PAGES delete sDefEditFont;
sDefEditFont = 0;
if (mChangingPages)
return;
if (leavingFrom->completed())
saveRecord();
mMainTable->unloadRecord();
mEditing = false;
mNew = false;
}
void dbEditMgr::newRecord()
{
InvalidateAllPages();
assert(mMainTable); // should be setup by now!
mNew = mEditing = true;
mMainTable->newRecord();
if (mCurrDialog) { // left over from closing last form, NOT a page transition
// NOT NEEDED - ALL OUR DIALOGS ARE deleteOnClose() delete mCurrDialog;
mCurrDialog = 0;
}
}
void dbEditMgr::firstRecord()
{
if (mEditing) {
InvalidateAllPages();
mMainTable->first();
}
else
browserSelectFirst();
}
void dbEditMgr::nextRecord()
{
if (mEditing) {
InvalidateAllPages();
mMainTable->next();
}
else
browserSelectNext();
}
void dbEditMgr::prevRecord()
{
if (mEditing) {
InvalidateAllPages();
mMainTable->prev();
}
else
browserSelectPrev();
}
void dbEditMgr::lastRecord()
{
if (mEditing) {
InvalidateAllPages();
mMainTable->last();
}
else
browserSelectLast();
}
void dbEditMgr::InvalidateAllPages()
{
unsigned int numPages = mPages.count();
for (unsigned int i=0; i<numPages; i++) {
OOF_MixEditPage* thePage = (OOF_MixEditPage*) mPages[i]; // safe downcast
thePage->invalidatePage();
}
}
void dbEditMgr::appendPage(OOF_MixEditPage* thePage)
{
mPages.append((long) thePage);
}
void dbEditMgr::saveRecord()
{
assert(mMainTable); // should be setup by now!
mMainTable->saveRecord();
UpdateDisplayForEditedRecord();
}
void dbEditMgr::UpdateDisplayForEditedRecord()
{
// do nothing - subclass overrides if it needs update
}
void dbEditMgr::startPageTransition(zCommandEvt* ev)
{
if (mMenu) {
if (mCurrPageCommandNum)
mMenu->checkItem(mCurrPageCommandNum, FALSE);
}
if (mEditing) {
assert(mCurrDialog); // leaving this one
mChangingPages = true;
mCurrDialog->endOk(ev); // will trigger a callback to us leavingPage()
mChangingPages = false;
// NOT NEEDED - ALL OUR DIALOGS ARE deleteOnClose() delete mCurrDialog;
mCurrDialog = 0; // in case some bright spark forgets to follow with completePageTransition
}
else
if (mCurrDialog) { // is leftover from previous edit
// NOT NEEDED - ALL OUR DIALOGS ARE deleteOnClose() delete mCurrDialog;
mCurrDialog = 0;
}
mEditing = true;
}
void dbEditMgr ::completePageTransition(zVBXFormDialog* newDialog, const int newPageMenuItemNum)
{
if (mMenu) {
mCurrPageCommandNum = newPageMenuItemNum;
if (mCurrPageCommandNum)
mMenu->checkItem(mCurrPageCommandNum, TRUE);
}
mCurrDialog = newDialog;
}
void dbEditMgr::saveAsText(char* fileName)
{
ofstream fs(fileName);
mDatabase->dumpData(fs);
fs.close();
}
void dbEditMgr::warnUser(ostream& os)
{
#ifdef __MWERKS__
cout << *(os.rdbuf()); // they don't define operator<<(streambuf*)
#else
#ifdef _Windows
strstream oss;
oss << os.rdbuf() << ends;
char* s = oss.str();
::MessageBox(0, s, "Warning", MB_ICONEXCLAMATION);
oss.rdbuf()->freeze(0); // leave buffer for stream to delete
#else
cout << os.rdbuf();
#endif
#endif
}
// -------------------------------------------------------
// O O F _ M i x E d i t P a g e
// -------------------------------------------------------
OOF_MixEditPage::OOF_MixEditPage(zVBXFormDialog* thisDialog, dbEditMgr* editMgr) :
mEditFont(0),
mEditMgr(editMgr),
mValid(true),
mThisDialog(thisDialog)
{
mEditFont = mEditMgr->enableDefEditFont(); // must call before creating edit fields
mEditMgr->appendPage(this);
}
OOF_MixEditPage::~OOF_MixEditPage()
{
delete mEditFont;
}
void OOF_MixEditPage::bringToFront()
{
dbEditMgr::setDefEditFont(mEditFont);
if (!mValid) {
mThisDialog->setControlsToDefault();
}
mThisDialog->show();
}
// -------------------------------------------------------
// O O F _ M i x E d i t F i e l d
// -------------------------------------------------------
void OOF_MixEditField::CompleteInit(zControl* child)
{
zFont* defFont = dbEditMgr::defEditFont();
if (defFont)
child->setFont(defFont, FALSE);
}
// -------------------------------------------------------
// z d b E d i t L i n e
// -------------------------------------------------------
zdbEditLine::zdbEditLine(zFrameWin* w, int id, dbChar& dest_, unsigned long flags) :
zEditLine(w, id, 0, flags),
mField(dest_)
{
CompleteInit(this);
}
int zdbEditLine::storeData() {
mField = text();
return 1;
}
int zdbEditLine::setToDefault() {
text(mField);
return 1;
}
// -------------------------------------------------------
// z d b E d i t C o m b o
// -------------------------------------------------------
zdbEditCombo::zdbEditCombo(zFrameWin* w, int id, dbChar& dest_, unsigned long flags) :
zComboBoxFull(w, id, (zString*)0, flags),
mField(dest_)
{
CompleteInit(this);
}
int zdbEditCombo::storeData() {
zString temp;
getEditText(temp);
mField = temp;
return 1;
}
int zdbEditCombo::setToDefault() {
add(mField);
selection(mField);
return 1;
}
// -------------------------------------------------------
// z d b E d i t D a t e
// -------------------------------------------------------
zdbEditDate::zdbEditDate(zFrameWin* w, int id, dbDate& dest_, unsigned long flags) :
zEditLine(w, id, 0, flags),
mField(dest_)
{
CompleteInit(this);
}
int zdbEditDate::storeData() {
mField = text();
return 1;
}
int zdbEditDate::setToDefault() {
text(mField);
return 1;
}
// -------------------------------------------------------
// z d b C h a r E d i t B o x
// -------------------------------------------------------
zdbCharEditBox::zdbCharEditBox(zWindow *w,zSizer* siz,DWORD style, dbChar& dest_, int id) :
zEditBox(w, siz, style, 0, id),
mField(dest_)
{
// CompleteInit(this);
}
zdbCharEditBox::zdbCharEditBox(zFrameWin* w,int id, dbChar& dest_, unsigned long flags) :
zEditBox(w, id, 0, flags),
mField(dest_)
{
// CompleteInit(this);
}
int zdbCharEditBox::storeData() {
mField = text();
return 1;
}
int zdbCharEditBox::setToDefault() {
text(mField);
return 1;
}
// -------------------------------------------------------
// z d b T e x t E d i t B o x
// -------------------------------------------------------
zdbTextEditBox::zdbTextEditBox(zWindow *w,zSizer* siz,DWORD style, dbText& dest_, int id) :
zEditBox(w, siz, style, 0, id),
mField(dest_)
{
CompleteInit(this);
}
zdbTextEditBox::zdbTextEditBox(zFrameWin* w,int id, dbText& dest_, unsigned long flags) :
zEditBox(w, id, 0, flags),
mField(dest_)
{
CompleteInit(this);
}
int zdbTextEditBox::storeData() {
mField = text();
return 1;
}
int zdbTextEditBox::setToDefault() {
text(mField);
return 1;
}
// -------------------------------------------------------
// z d b R a d i o G r o u p
// -------------------------------------------------------
zdbRadioGroup::zdbRadioGroup(zFrameWin* w,int idLo, int idHi, dbShortInt& dest_) :
zRadioGroup(w, idLo, idHi),
mField(dest_)
{
// CompleteInit(this);
}
int zdbRadioGroup::storeData() {
int temp;
setStoreAddr(&temp);
zRadioGroup::storeData(); // let parent do all the formatting
mField = temp; // copy value back to record buffer via assignment
setStoreAddr(0);
return 1;
}
int zdbRadioGroup::setToDefault() {
int temp;
temp = mField; // get value from record buffer via cast oper
setStoreAddr(&temp);
zRadioGroup::setToDefault(); // let the parent do the formatting
setStoreAddr(0);
return 1;
}
// -------------------------------------------------------
// z d b S h o r t E d i t
// -------------------------------------------------------
zdbShortEdit::zdbShortEdit(zFrameWin* w,int id, dbShortInt& dest_, char *pictStr, unsigned long flags) :
zIntEdit(w, id, 0, pictStr, flags),
mField(dest_)
{
// CompleteInit(this);
}
zdbShortEdit::zdbShortEdit(zFrameWin* w,int id, dbShortInt& dest_, zFormatter *formatter, unsigned long flags) :
zIntEdit(w, id, 0, formatter, flags),
mField(dest_)
{
// CompleteInit(this);
}
zdbShortEdit::zdbShortEdit(zFrameWin* w,int id, dbShortInt& dest_, unsigned long flags) :
zIntEdit(w, id, 0, flags),
mField(dest_)
{
// CompleteInit(this);
}
zdbShortEdit::zdbShortEdit(zWindow *w,zSizer* siz, DWORD style, int id , dbShortInt& dest_, char *pictStr, unsigned long flags) :
zIntEdit(w, siz, style, id, 0, pictStr, flags),
mField(dest_)
{
// CompleteInit(this);
}
zdbShortEdit::zdbShortEdit(zWindow *w,zSizer* siz, DWORD style, int id , dbShortInt& dest_, zFormatter *formatter, unsigned long flags) :
zIntEdit(w, siz, style, id, 0, formatter, flags),
mField(dest_)
{
// CompleteInit(this);
}
zdbShortEdit::zdbShortEdit(zWindow *w,zSizer* siz, DWORD style, int id , dbShortInt& dest_, unsigned long flags) :
zIntEdit(w, siz, style, id, 0, flags),
mField(dest_)
{
// CompleteInit(this);
}
int zdbShortEdit::storeData() {
int temp;
setStoreAddr(&temp);
zIntEdit::storeData(); // let parent do all the formatting
mField = temp; // copy value back to record buffer via assignment
setStoreAddr(0);
return 1;
}
int zdbShortEdit::setToDefault() {
int temp;
temp = mField; // get value from record buffer via cast oper
setStoreAddr(&temp);
zIntEdit::setToDefault(); // let the parent do the formatting
setStoreAddr(0);
return 1;
}
// -------------------------------------------------------
// z d b L o n g E d i t
// -------------------------------------------------------
zdbLongEdit::zdbLongEdit(zFrameWin* w,int id, dbLong& dest_, char *pictStr, unsigned long flags) :
zLongEdit(w, id, 0, pictStr, flags),
mField(dest_)
{
// CompleteInit(this);
}
zdbLongEdit::zdbLongEdit(zFrameWin* w,int id, dbLong& dest_, zFormatter *formatter, unsigned long flags) :
zLongEdit(w, id, 0, formatter, flags),
mField(dest_)
{
// CompleteInit(this);
}
zdbLongEdit::zdbLongEdit(zFrameWin* w,int id, dbLong& dest_, unsigned long flags) :
zLongEdit(w, id, 0, flags),
mField(dest_)
{
// CompleteInit(this);
}
zdbLongEdit::zdbLongEdit(zWindow *w,zSizer* siz, DWORD style, int id , dbLong& dest_, char *pictStr, unsigned long flags) :
zLongEdit(w, siz, style, id, 0, pictStr, flags),
mField(dest_)
{
// CompleteInit(this);
}
zdbLongEdit::zdbLongEdit(zWindow *w,zSizer* siz, DWORD style, int id , dbLong& dest_, zFormatter *formatter, unsigned long flags) :
zLongEdit(w, siz, style, id, 0, formatter, flags),
mField(dest_)
{
// CompleteInit(this);
}
zdbLongEdit::zdbLongEdit(zWindow *w,zSizer* siz, DWORD style, int id , dbLong& dest_, unsigned long flags) :
zLongEdit(w, siz, style, id, 0, flags),
mField(dest_)
{
// CompleteInit(this);
}
int zdbLongEdit::storeData() {
long temp;
setStoreAddr(&temp);
zLongEdit::storeData();
setStoreAddr(0);
mField = temp;
return 1;
}
int zdbLongEdit::setToDefault() {
long temp;
temp = mField;
setStoreAddr(&temp);
zLongEdit::setToDefault();
setStoreAddr(0);
return 1;
}
int zdbLongEdit::checkData()
{
if (mField.mHasRange) {
long temp;
setStoreAddr(&temp);
zLongEdit::storeData();
setStoreAddr(0);
if (mField.validate(temp))
return 1;
else {
dbEditMgr::warnUser(ostrstream() <<
mField.fieldName() << " requires values between " << mField.mMin << " and "
<< mField.mMax
);
return 0;
}
}
else
return 1;
}
// -------------------------------------------------------
// z d b R e a l E d i t
// -------------------------------------------------------
zdbRealEdit::zdbRealEdit(zFrameWin* w,int id, dbReal& dest_, char *pictStr, unsigned long flags) :
zDoubleEdit(w, id, 0, pictStr, flags),
mField(dest_)
{
// CompleteInit(this);
}
zdbRealEdit::zdbRealEdit(zFrameWin* w,int id, dbReal& dest_, zFormatter *formatter, unsigned long flags) :
zDoubleEdit(w, id, 0, formatter, flags),
mField(dest_)
{
// CompleteInit(this);
}
zdbRealEdit::zdbRealEdit(zFrameWin* w,int id, dbReal& dest_, unsigned long flags) :
zDoubleEdit(w, id, 0, flags),
mField(dest_)
{
// CompleteInit(this);
}
zdbRealEdit::zdbRealEdit(zWindow *w,zSizer* siz, DWORD style, int id , dbReal& dest_, char *pictStr, unsigned long flags) :
zDoubleEdit(w, siz, style, id, 0, pictStr, flags),
mField(dest_)
{
// CompleteInit(this);
}
zdbRealEdit::zdbRealEdit(zWindow *w,zSizer* siz, DWORD style, int id , dbReal& dest_, zFormatter *formatter, unsigned long flags) :
zDoubleEdit(w, siz, style, id, 0, formatter, flags),
mField(dest_)
{
// CompleteInit(this);
}
zdbRealEdit::zdbRealEdit(zWindow *w,zSizer* siz, DWORD style, int id , dbReal& dest_, unsigned long flags) :
zDoubleEdit(w, siz, style, id, 0, flags),
mField(dest_)
{
// CompleteInit(this);
}
int zdbRealEdit::storeData() {
double temp;
setStoreAddr(&temp);
zDoubleEdit::storeData();
mField = temp;
setStoreAddr(0);
return 1;
}
int zdbRealEdit::setToDefault() {
double temp;
temp = mField;
setStoreAddr(&temp);
zDoubleEdit::setToDefault();
setStoreAddr(0);
return 1;
}
// -------------------------------------------------------
// d b B r o w s e V R o w M o d e l
// -------------------------------------------------------
int dbBrowseVRowModel::discardRow(unsigned long row)
{
return 1; // no editing so no writeback
}
int dbBrowseVRowModel::demandLoadRow(unsigned long row)
{
// if (!mFields.source()->gotoRelativeRecord(row-1))
// return 0;
// for (unsigned int i=0; i<mFields.count(); i++) { // start field iteration (horizontal)
// dbField *theField = (dbField *) mFields[i]; // safe downcast
// char *theString = theField->copyAsChars();
// new zTableTextCell(this,theString,zTableLoc(i+1,row));
// delete[] theString;
// }
return 1;
}
void dbBrowseVRowModel::AppendBlankRow()
{
InsertBlankRow(getNumRows()+1);
}
void dbBrowseVRowModel::InsertBlankRow(unsigned long row)
{
for (unsigned int i=0; i<getNumCols(); i++)
new zTableTextCell(this,"",zTableLoc(i+1,row));
}
void dbBrowseVRowModel::coverWithReadOnly()
{
}
// -------------------------------------------------------
// S S T a b l e _ S h e e t
// -------------------------------------------------------
void SSTable_Sheet::selectCol(unsigned int theCol)
{
assert(theCol); // 1-based columns
Col() = theCol;
Row() = -1; // all rows
}
void SSTable_Sheet::selectRow(unsigned int theRow)
{
assert(theRow); // 1-based rows
Row() = theRow;
Col() = -1; // all cols
}
//
// parse Spread/VBX events down into something the table can use
// in the process uncoupling our table logic from how they handle
// editing changes
//
void SSTable_Sheet::DblClick(long Col, long Row)
{
mTable->receiveDoubleClick(Col, Row);
}
void SSTable_Sheet::EditMode(long Col, long Row, int Mode, int ChangeMade)
{
if (Mode==1) { // ENTERING
if (Row!=mCurRow) {
mCurRow = Row;
mTable->enterRow(Row);
}
}
else {
if (ChangeMade)
mTable->leaveModifiedCell(Col, Row);
}
}
// -------------------------------------------------------
// S S T a b l e
// -------------------------------------------------------
SSTable::SSTable(zWindow* w, zSizer* siz, int id_, DWORD style) :
CVBControl(w, siz, id_, "SSPP20.VBX", "SpreadSheet", "SSPP20", style),
mCurRow(-1)
{
mSheet = new SSTable_Sheet(this);
assert(mSheet);
}
SSTable::SSTable(zFrameWin* w, int id_) :
CVBControl(w, id_),
mCurRow(-1)
{
mSheet = new SSTable_Sheet(this);
assert(mSheet);
}
SSTable::~SSTable()
{
delete mSheet;
}
unsigned long SSTable::countRowsSelected()
{
if (mSheet->OperationMode() = SS_OP_MODE_SINGLE_SELECT)
return 1;
else
return mSheet->SelModeSelCount();
}
unsigned long SSTable::selectedRow()
{
unsigned long ret;
if (mSheet->OperationMode() = SS_OP_MODE_SINGLE_SELECT)
ret = mSheet->SelModeIndex()-1;
else
ret = mSheet->GetMultiSelItem(0)-1; // ASSUMES only one selected - you would NOT
// call this method if multiple selection
mSheet->Row() = ret+1; // set internal property to match so data updates correct row
return ret;
}
unsigned long SSTable::appendBlankRow()
{
unsigned long newRow = mSheet->MaxRows()+1;
mSheet->MaxRows() = newRow;
mSheet->Row() = newRow;
mSheet->Action() = SS_ACTION_INSERT_ROW;
mCurRow = newRow;
return newRow;
}
void SSTable::setRowColor(long newColor)
{
mSheet->Col() =-1; // whole row
mSheet->ForeColor() = newColor;
}
long SSTable::eventVBX(zVBXEvent *theEvent)
{
VBXEVENT *ptrEvent = theEvent->event();
mSheet->CallEvent(ptrEvent->EventIndex, ptrEvent->ParamList);
return 0;
}
void SSTable::selectRow(unsigned int theRow)
{
mSheet->selectRow(theRow);
if (mSheet->OperationMode() = SS_OP_MODE_SINGLE_SELECT) {
mSheet->SelModeIndex() = theRow;
mSheet->SelModeSelected() = TRUE;
}
}
// -------------------------------------------------------
// d b S S V ie w T a b l e
// -------------------------------------------------------
dbSSViewTable::dbSSViewTable(zWindow*w, zSizer* s, int id_, dbView& flds, DWORD style) :
SSTable(w, s, id_, style),
mFields(flds),
mHasWrappedCols(false)
{
}
dbSSViewTable::dbSSViewTable(zFrameWin*w, int id_, dbView& flds) :
SSTable(w, id_),
mFields(flds),
mHasWrappedCols(false)
{
}
void dbSSViewTable::SetColsFromView()
{
SetColHeadingsFromView();
SetColWidthsFromView();
}
void dbSSViewTable::SetColHeadingsFromView()
{
unsigned int numFields = mFields.count();
for (unsigned int col=0; col<numFields; col++) { // start field iteration (horizontal)
dbField *theField = (dbField *) mFields[col]; // safe downcast
mSheet->SetText(col+1, 0, theField->fieldName());
}
}
void dbSSViewTable::SetColWidthsFromView()
{
const int scrollBarWidth = 18;
const float twipsPerPixelFudgeFactor = 15.0;
zRect sheetRect;
getInterior(sheetRect); // device units (pixels) and include scrollbar?
// long totalTwips;
// mSheet->ColWidthToTwips(sheetRect.width(), totalTwips);
mSheet->UnitType() = SS_CELL_UNIT_TWIPS;
unsigned int numFields = mFields.count();
unsigned long totalColWidth=0;
for (unsigned int i=0; i<numFields; i++) {
dbField *theField = (dbField *) mFields[i]; // safe downcast
totalColWidth += theField->fieldEditLen();
}
// float twipsPerColChar = totalTwips / totalColWidth;
mSheet->ReDraw() = FALSE;
int sheetWidth = sheetRect.width() - scrollBarWidth;
float twipsPerColChar = (sheetWidth * twipsPerPixelFudgeFactor) / totalColWidth ;
for (unsigned int col=0; col<numFields; col++) { // start field iteration (horizontal)
dbField *theField = (dbField *) mFields[col]; // safe downcast
selectCol(col+1);
setCellTypeForField(theField);
mSheet->ColWidth() = twipsPerColChar * theField->fieldEditLen();
}
mSheet->ReDraw() = TRUE;
}
void dbSSViewTable::loadEntireTable()
{
unsigned int numFields = mFields.count();
mFields.source()->start();
mSheet->ReDraw() = FALSE;
unsigned long numRows = mFields.source()->count();
for (unsigned long row=1; row<=numRows; row++) { // iterate through records (vertical)
mSheet->Row() = row;
for (unsigned int col=0; col<numFields; col++) { // start field iteration (horizontal)
dbField *theField = (dbField *) mFields[col]; // safe downcast
char *str = theField->copyAsChars();
assert(str);
mSheet->SetText(col+1, row, str);
mSheet->Col() = col+1;
SetCellWidth(theField, str);
delete[] str;
}
adjustRowHeights();
mFields.source()->next();
}
mSheet->ReDraw() = TRUE;
}
void dbSSViewTable::addRowFromCurrentRecord()
{
appendBlankRow();
redrawCurrentRecord(RGB(255, 0, 0));
}
void dbSSViewTable::redrawCurrentRecord(long newColor)
{
int currentRow = mSheet->Row();
mSheet->ReDraw() = FALSE;
unsigned int numFields = mFields.count();
for (unsigned int col=0; col<numFields; col++) { // start field iteration (horizontal)
dbField *theField = (dbField *) mFields[col]; // safe downcast
char *str = theField->copyAsChars();
mSheet->Col() = col+1;
mSheet->Text() = str;
SetCellWidth(theField, str);
}
adjustRowHeights();
setRowColor(newColor);
// mSheet->OperationMode() = SS_OP_MODE_NORMAL;
mSheet->ReDraw() = TRUE;
mSheet->Col() = -1;
mSheet->Row() = -1;
mSheet->SortBy() = SS_SORT_BY_ROW;
mSheet->SortKey(1) = 1;
mSheet->SortKeyOrder(1)=SS_SORT_ORDER_ASCENDING;
mSheet->Action() = SS_ACTION_SORT;
// mSheet->OperationMode() = SS_OP_MODE_SINGLE_SELECT;
selectRow(currentRow);
setDirty();
update();
}
short dbSSViewTable::cellTypeOfField(dbField* theField)
{
switch (theField->fieldType()) {
case intField : return SS_CELL_TYPE_INTEGER;
case longField : return SS_CELL_TYPE_INTEGER;
case realField : return SS_CELL_TYPE_FLOAT;
default : return SS_CELL_TYPE_EDIT;
}
return SS_CELL_TYPE_EDIT;
}
void dbSSViewTable::setCellTypeForField(dbField* theField)
{
switch (theField->fieldType()) {
case intField : mSheet->CellType() = SS_CELL_TYPE_INTEGER;
break;
case longField : mSheet->CellType() = SS_CELL_TYPE_INTEGER;
break;
case realField : mSheet->CellType() = SS_CELL_TYPE_FLOAT;
break;
case dateField : colTypeIsDate(mSheet->Col(), "01011960", "12312010");
break;
default : mSheet->CellType() = SS_CELL_TYPE_EDIT;
}
}
void dbSSViewTable::colTypeIsDate(const int colNum, const char* minDate, const char* maxDate)
{
selectCol(colNum);
mSheet->TypeDateCentury() = FALSE;
mSheet->TypeHAlign() = SS_CELL_H_ALIGN_CENTER;
mSheet->TypeDateFormat() = SS_CELL_DATE_FORMAT_DDMMYY;
mSheet->CellType() = SS_CELL_TYPE_DATE;
// if (minDate)
// mSheet->TypeDateMin() = minDate;
// if (maxDate)
// mSheet->TypeDateMax() = maxDate;
}
void dbSSViewTable::colTypeIsCheck(const int colNum)
{
// see page 78 of SS reference
selectCol(colNum);
mSheet->CellType() = SS_CELL_TYPE_CHECKBOX;
mSheet->TypeCheckText() = "";
mSheet->TypeCheckCenter() = TRUE;
// FROM BOOK, the following is in several examples but crashed me!
// mSheet->TypeCheckPicture(0) = mSheet->LoadPicture("");
// mSheet->TypeCheckPicture(1) = mSheet->LoadPicture("");
// mSheet->TypeCheckPicture(2) = mSheet->LoadPicture("");
// mSheet->TypeCheckPicture(3) = mSheet->LoadPicture("");
// mSheet->TypeCheckPicture(4) = mSheet->LoadPicture("");
// mSheet->TypeCheckPicture(5) = mSheet->LoadPicture("");
}
void dbSSViewTable::colTypeIsCombo(const int colNum, const char* comboString)
{
selectCol(colNum);
mSheet->CellType() = SS_CELL_TYPE_COMBOBOX;
mSheet->TypeComboBoxList() = comboString;
mSheet->TypeComboBoxEditable() = FALSE;
}
void dbSSViewTable::colWrapsText(const int colNum)
{
selectCol(colNum);
mSheet->TypeEditMultiLine() = TRUE;
mSheet->TypeTextWordWrap() = TRUE;
mHasWrappedCols = true;
}
void dbSSViewTable::adjustRowHeights()
{
if (mHasWrappedCols) {
float fHeight = mSheet->MaxTextRowHeight();
mSheet->RowHeight() = fHeight;
}
}
void dbSSViewTable::SetCellWidth(dbField* theField, char* contents)
{
if (theField->fieldType()!=textField)
mSheet->TypeEditLen() = theField->fieldEditLen();
else
mSheet->TypeEditLen() = 16000; // estimate
}
int dbSSViewTable::setToDefault()
{
mSheet->MaxRows() = mFields.source()->count();
loadEntireTable();
return 1;
}
// -------------------------------------------------------
// d b S S B r o w s e T a b l e
// -------------------------------------------------------
dbSSBrowseTable::dbSSBrowseTable(zWindow*w, zSizer* s, int id_, dbEditMgr* editMgr, dbView& flds, DWORD style) :
dbSSViewTable(w, s, id_, flds, style),
mEditMgr(editMgr)
{
SetupSheet();
SetColHeadingsFromView();
}
dbSSBrowseTable::dbSSBrowseTable(zFrameWin*w, int id_, dbEditMgr* editMgr, dbView& flds) :
dbSSViewTable(w, id_, flds),
mEditMgr(editMgr)
{
SetupSheet();
SetColHeadingsFromView();
}
void dbSSBrowseTable::SetupSheet()
{
mSheet->MaxCols() = mFields.count();
mSheet->MaxRows() = mFields.source()->count();
mSheet->OperationMode() = SS_OP_MODE_SINGLE_SELECT;
mSheet->DisplayRowHeaders() = FALSE;
mSheet->DisplayColHeaders() = TRUE;
mSheet->AllowResize() = TRUE;
// mSheet->VScrollSpecial() = TRUE;
// mSheet->ScrollBarExtMode() = TRUE;
mSheet->CursorStyle() = SS_CURSOR_STYLE_ARROW;
selectFirst();
}
int dbSSBrowseTable::size(zSizeEvt* evt)
{
int ret = zWindow::size(evt);
SetColWidthsFromView();
return ret;
}
void dbSSBrowseTable::receiveDoubleClick(long Col, long Row)
{
if (mEditMgr)
mEditMgr->doubleClickedBrowser(Row-1);
}
void dbSSBrowseTable::selectFirst()
{
mCurRow = 1;
selectRow(mCurRow);
}
void dbSSBrowseTable::selectNext()
{
mCurRow++;
selectRow(mCurRow);
}
void dbSSBrowseTable::selectPrev()
{
mCurRow--;
selectRow(mCurRow);
}
void dbSSBrowseTable::selectLast()
{
mCurRow = mSheet->MaxRows();
selectRow(mCurRow);
}
void dbSSBrowseTable::SetCellWidth(dbField* theField, char* contents)
{
mSheet->TypeEditLen() = strlen(contents);
}
// -------------------------------------------------------
// d b S S E d i t T a b l e
// -------------------------------------------------------
dbSSEditTable::dbSSEditTable(zFrameWin*w, int id_, dbView& flds) :
dbSSViewTable(w, id_, flds)
{
SetupSheet();
SetColsFromView();
}
void dbSSEditTable::SetupSheet()
{
mSheet->MaxCols() = mFields.count();
mSheet->MaxRows() = mFields.source()->count();
mSheet->OperationMode() = SS_OP_MODE_NORMAL;
// was SS_OP_MODE_ROWMODE; but have problems with controls not visible in that case
// Mike Betham preferred look with normal - confusing with combo boxes having to
// double-click to enter editing mode then click again on the control
mSheet->ProcessTab() = TRUE; // tab cells, not controls
mSheet->EditModePermanent() = TRUE;
mSheet->DisplayRowHeaders() = FALSE;
mSheet->DisplayColHeaders() = TRUE;
mSheet->AllowResize() = TRUE;
mSheet->CursorStyle() = SS_CURSOR_STYLE_ARROW;
}
unsigned long dbSSEditTable::appendBlankRow()
{
unsigned long newRow = SSTable::appendBlankRow();
mFields.source()->newRecord();
unsigned int numFields = mFields.count();
for (unsigned int col=0; col<numFields; col++) { // start field iteration (horizontal)
dbField *theField = (dbField *) mFields[col]; // safe downcast
mSheet->Col() = col+1;
dbSSViewTable::SetCellWidth(theField);
}
return newRow;
}
void dbSSEditTable::enterRow(long Row)
{
if (mCurRow != Row) {
mCurRow = Row;
mFields.source()->gotoRelativeRecord(Row-1);
}
}
void dbSSEditTable::leaveModifiedCell(long Col, long Row)
{
assert(Row==mCurRow);
mSheet->Col() = Col;
mSheet->Row() = Row;
char *cellText = mSheet->GetText(Col, Row);
dbField *theField = (dbField *) mFields[(int)(Col-1)]; // safe downcast
theField->setString(cellText);
adjustRowHeights();
}
// -------------------------------------------------------
// d b z L i s t B r o w s e T a b l e
// -------------------------------------------------------
dbzListBrowseTable::dbzListBrowseTable(zWindow*w, zSizer* s, int id_, dbView& flds, DWORD style) :
zListBox(w, s, style, 0, id_),
mFields(flds)
{
}
void dbzListBrowseTable::loadEntireTable()
{
mFields.source()->start();
unsigned int numFields = mFields.count();
while (mFields.source()->more()) {
ostrstream oss;
for (unsigned int col=0; col< numFields; col++) { // start field iteration (horizontal)
dbField *theField = (dbField *) mFields[col]; // safe downcast
char* str = theField->copyAsChars() ;
// oss.width(theField->FieldLen());
// if (theField->FieldType()==charField)
// oss.setf(ios::left, ios::adjustfield);
// else
// oss.setf(ios::right, ios::adjustfield);
oss << str << '\t';
// delete[] str;
}
char* str = oss.str();
if (str)
add(str);
mFields.source()->next();
}
}